/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package logica.validacion;

import java.io.File;
import java.util.Date;
import java.util.regex.Pattern;

/**
 *
 * @author Gonzalo
 */
public class CapaValidacion {

    public final static String CaracteresEspeciales = "áéíóúü\'";
    public final static String CaracteresEspecialesSinApostrofo = "áéíóúü";

    /**
     * Valida que una cadena no sea nula.
     *
     * @param cadena La cadena a validar
     * @return true si es válida, false en caso contrario
     */
    public static boolean validarCampoObligatorio(String cadena) {
        if (cadena.length() > 0 && !esCadenaVacia(cadena)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Verifica si la cadena recibida solo contiene caracteres en blanco
     *
     * @param cadena La cadena a validar
     * @return true si es vacia, false en caso contrario
     */
    public static boolean esCadenaVacia(String cadena) {
        char[] cadenaTemp = cadena.toCharArray();
        int count = 0;

        if (cadena.isEmpty()) {
            return false;
        }

         for (int i = 0; i < cadenaTemp.length; i++) {
             if (Character.valueOf(cadenaTemp[i]).toString().equals(" ")) {
                 count = count +1;
             }
         }

        if (count == cadenaTemp.length) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determina si una letra es ñ o no.
     *
     * @param letra La letra
     * @return true si es ñ, false en caso contrario
     *
     */
    public static boolean esEnie(String letra) {
        String letraTemp = letra.toLowerCase();

        if (letraTemp.compareTo("ñ") == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Indica si una cadena es o no alfabética.
     * (Son alfabéticas las cadenas que contengan un rango de caracteres de
     * [aZ.]) y además los siguientes caracteres: á é í ó ú ü '
     * No se valida la letra ñ ya que se permite solo un caracter especial.
     *
     * @param cadena La cadena a analizar
     * @return true si es alfabética, false en caso contrario
     */
    public static boolean esAlfabetico(String cadena) {
        String cadenaTemp = cadena.toLowerCase();
        boolean retorno = true;
        boolean yaTieneCaracterEspecial = false;
        int enie = 0;

        if (cadenaTemp.isEmpty() || esCadenaVacia(cadena)) {
            retorno = false;
        }

        char[] cadenaSinEspacios = cadenaTemp.trim().toCharArray();
        Pattern patron = Pattern.compile("[a-z]");


        for (int i = 0; i < cadenaSinEspacios.length; i++) {
            if (patron.matcher(Character.valueOf(
                    cadenaSinEspacios[i]).toString()).matches()) {
                ; // No hace nada
            } else if (esCaracterEspecial(String.valueOf(cadenaSinEspacios[i]))
                    && !yaTieneCaracterEspecial) {
                yaTieneCaracterEspecial = true;

            } else if (esEnie(String.valueOf(cadenaSinEspacios[i])) && enie < 2) {
                enie++;

            } else {
                retorno = false;
            }
        }
        return retorno;
    }

    /** 
     * Indica si una cadena es o no alfabética.
     * (Son alfabéticas las cadenas que contengan un rango de caracteres de
     * [aA-zZ.]) y además los siguientes caracteres: á é í ó ú ü Á É Í Ó Ú '.
     * No se valida la letra ñ ya que se permite solo un caracter especial.
     *
     * @param cadena La cadena a analizar
     * @return true si es alfabética, false en caso contrario
     */
    public static boolean esAlfabeticoConPunto(String cadena) {
        String cadenaTemp = cadena.toLowerCase();
        boolean esValido = true;
        boolean yaTieneCaracterEspecial = false;
        int enie = 0;

        if (cadenaTemp.isEmpty() || esCadenaVacia(cadena)) {
            esValido = false;
        }

        char[] cadenaSinEspacios = cadenaTemp.trim().toCharArray();
        Pattern patron = Pattern.compile("[a-zA-Z.]");


        for (int i = 0; i < cadenaSinEspacios.length; i++) {
            if (patron.matcher(Character.valueOf(
                    cadenaSinEspacios[i]).toString()).matches()) {
                ; // No hace nada
            } else if (esCaracterEspecial(String.valueOf(cadenaSinEspacios[i]))
                    && !yaTieneCaracterEspecial) {
                yaTieneCaracterEspecial = true;

            } else if (esEnie(String.valueOf(cadenaSinEspacios[i])) && enie < 2) {
                enie++;

            } else {
                esValido = false;
            }
        }
        return esValido;
    }

    /**
     * Indica si una letra es del tipo á é í ó ú ü Á É Í Ó Ú '.
     *
     * @param letra La letra
     * @return true si es caracter especial, false en caso contrario
     */
    public static boolean esCaracterEspecial(String letra) {
        return CaracteresEspeciales.contains(letra);
    }

    /**
     * Indica si una letra es del tipo á é í ó ú ü.
     *
     * @param letra La letra
     * @return true si es caracter especial, false en caso contario
     */
    public static boolean esCaracterEspecialSinApostrofo(String letra) {
        return CaracteresEspecialesSinApostrofo.contains(letra);
    }

    /**
     * Indica si una cadena es numérica.
     *
     * @param palabra Cadena a analizar
     * @return true en caso correcto, false en caso contrario
     */
    public static boolean esTodoNumero(String palabra) {
        Pattern patronPiso = Pattern.compile("[0-9]*");

        if (patronPiso.matcher(palabra).matches()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Valida una fecha según diferentes factores.
     *
     * @param unaFecha El tipo Date que se recibe
     * @param campo El texto ingresado en la fecha
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es fecha correcta, false en caso contrario
     */
    public static boolean validarFecha(Date unaFecha, String campo,
            boolean esObligatorio) {
        if (esObligatorio) {
            return (unaFecha != null);
        } else {
            return ((unaFecha != null || campo.equals("")));
        }
    }

    /**
     * Verifica que el tamaño del archivo sea menor al permitido.
     *
     * @param ruta La ruta del archivo a validar
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarArchivo(String ruta, boolean esObligatorio) {
        boolean esValido = true;

        if (esObligatorio && ruta.isEmpty()) {
            esValido = false;
        }

        //Expresado en bytes = 1GB
        int tamanioPermitido = 1024000000;
        int tamanioFotografia = (int) new File(ruta).length();

        if (tamanioFotografia > tamanioPermitido) {
            esValido = false;
        }

        return esValido;
    }

}
